#1.#创建一个Robot(机器人)类,完成机器人相应的work()、rest()、charge()等行为,若干行为间不可冲突。
# 设计一个函数统计Robot类中,统计出方法、函数、类的个数。

# 定义Robot类
class Robot:

    energy = 10

   #机器人工作
    def work(self):
        if self.energy >= 10:
            self.energy -= 10
            print("机器人正在工作")
            print("...")
            print(f"工作完毕，目前电量为:{self.energy}")
            print()
        else:
            print("电量不足，请充电")
            print()

    #机器人休息
    def rest(self):
        print("机器人正在休息")
        print()

    def charge(self):
        self.energy = 50
        print("正在充电")
        print("...")
        print(f"充电完成，机器人的电量为:{self.energy}")
        print()

    # 设计一个函数来统计Robot类中的方法、变量和类的个数


def Fun_count(cls):
    method_count = 0
    variable_count = 0
    classe_count = 0

    # 检查类变量
    for attr_name in cls.__dict__:
        attr = getattr(cls, attr_name)

        # 统计方法
        if callable(attr) and not attr_name.startswith("__"):
            method_count += 1
            # 统计变量（不包括方法）
        elif not callable(attr) and not attr_name.startswith("__"):
            variable_count += 1

            # 检查是否包含嵌套类
    for attr_name, attr in inspect.getmembers(cls):
        if inspect.isclass(attr) and attr.__module__ == cls.__module__:
            classe_count += 1

    return method_count, variable_count, classe_count


# 导入inspect模块以支持类的检查
import inspect

if __name__ =="__main__":
    # 创建一个Robot实例
    robot = Robot()

    # 调用Robot类的方法
    robot.work()
    robot.work()
    robot.charge()
    robot.work()
    robot.rest()

    # 使用设计的函数统计Robot类中的方法、变量和类的个数
    methods, variables, classes = Fun_count(Robot)
    print(f"方法的个数: {methods}")
    print(f"变量的个数: {variables}")
    print(f"类的个数: {classes}")


#2.现有一个基类Animal，其中有一个方法是show(),请使用多态性方法,实现Cat、Dog、Tiger中的show()方法。

#抽象类
class Animal:
    def show(self):
        pass

#子类
class Cat(Animal):
    def show(self):
        print("飞檐走壁")

class Dog(Animal):
    def show(self):
        print("丹心耿耿")

class Tiger(Animal):
    def show(self):
        print("兽中之王")


def Fun_show(test):
    test.show()

if __name__ =="__main__":
    # 创建对象
    test_1 = Cat()
    test_2 = Dog()
    test_3 = Tiger()

    # 调用多态
    Fun_show(test_1)
    Fun_show(test_2)
    Fun_show(test_3)

# 3.3.编写一个队列类myQueue,完成对列的初始化、删除、入队和出库等方法。
#队列类
class myQueue:
    lt = None
    size = None

    #构造
    def __init__(self):
        self.lt = list()
        self.size = 0

    #入队列
    def Push(self,n):
        self.lt.append(n)
        self.size +=1

    #删除首元素
    def Pop(self):
        for i in range(1,self.size):
            self.lt[i-1] = self.lt[i]

        self.size -= 1

    #获取首元素
    def Get_first(self):
        return self.lt[0]

    #元素个数
    def Size(self):
        return self.size

    #判断为空
    def Empty(self):
        return self.size == 0

#测试一
if __name__ == '__main__':
    test = myQueue()
    #入队
    test.Push(1)
    test.Push(2)
    test.Push(3)
    test.Push(4)

    #遍历
    for i in range(0,test.Size()):
        print(test.Get_first())
        test.Pop()

    # 判断元素个数
    print(test.Size())


#测试二
if __name__ == '__main__':
    test = myQueue()
    #入队
    test.Push(1)
    test.Push(2)
    test.Push(3)
    test.Push(4)

    #出队
    print(test.Get_first())
    test.Pop()

    #判断空
    print(test.Empty())

    #出队
    print(test.Get_first())
    test.Pop()

    #元个数
    print(test.Size())

#4.面向对象模拟电影院自动售票系统实现自动选择电影、场次、座位。

class ciname:
    #记录信息
    sum = {}
    #选择电影
    def select_film(self):
        print("请选择您想看的电影：")
        print("1.《功夫熊猫4》")
        print("2.《小鬼当家》")
        print("3.《人在囧途》")
        print("4.《变形金刚》")

        n = int(input('请输入:'))
        if n == 1:
            self.sum["电影"] = "《功夫熊猫4》"

        if n == 2:
            self.sum["电影"] = "《小鬼当家》"

        if n == 3:
            self.sum["电影"] = "《人在囧途》"

        if n == 4:
            self.sum["电影"] = "《变形金刚》"
        print()

      #选择座位
    def select_position(self):
        print("座位号为：1 ~ 40")
        n = int(input("请选择您的座位："))
        self.sum["座位"] = n
        print()

      #选择场次
    def select_second(self):
        print("今天的场次：")
        print("1.上午 7.00 - 8.30")
        print("2.上午 9.00 - 10.30")
        print("3.下午 2.00 - 3.30")
        print("4.下午 4.00 - 5.30")

        n = int(input("请输入:"))

        if n == 1:
            self.sum["电影场次"] = "上午 7.00 - 8.30"

        if n == 2:
            self.sum["电影场次"] = "上午 9.00 - 10.30"

        if n == 3:
            self.sum["电影场次"] = "上午 2.00 - 3.30"

        if n == 4:
            self.sum["电影场次"] = "上午 4.00 - 5.30"
        print()

      #打印信息
    def Print(self):
        print("您的信息为：")
        print(self.sum)
        n = input("是否确认( Y or N )：")
        if n =="Y":
            print("恭喜您，希望您观影愉快")
        else:
            print("请重新进入系统")

if __name__ =="__main__":
    #创建对象
    test = ciname()
    #选择电影
    test.select_film()
    #选择场次
    test.select_second()
    #选择座位
    test.select_position()
    #打印信息
    test.Print()

#5. 假设学校成员类(SchoolMember)具有成员的姓名（name）、年龄（age）、性别(sex)属性。教师类（Teacher）继承了学校成员类，
# 该类还记录了教师的职称(title)、工资(salary)、奖金(prize)等信息。学生类（Student）也继承了学校成员类，
# 该类还记录了学生所属系部(dept)、成绩(score)等信息。请定义以上3个类，要求同时满足如下功能：
#（1）创建教师和学生对象时需要调用父类方法进行必要的初始化;
#（2）能反映学校成员总人数的增减变化，即每创建一个对象时，则总人数加1；而对象注销时，总人数减1;
#（3）能够计算每位教师的总收入（工资+奖金），虽然不允许直接访问总收入，但可以通过提供相应的方法返回总收入值;
#（4）能使用print()函数输出每个对象的相关信息。

#学校类
class SchoolMember:
    # 记录学校成员总人数
    sum = 0

    def __init__(self, name, age, sex):
        self.name = name
        self.age = age
        self.sex = sex
        # 创建一个对象时，总人数加1
        SchoolMember.sum += 1

    def __del__(self):
        # 对象被销毁时，总人数减1
        SchoolMember.sum -= 1
    def print_info(self):
        print(f"姓名: {self.name}, 年龄: {self.age}, 性别: {self.sex}")

    @classmethod
    def get_sum(cls):
        return cls.sum

#教师类
class Teacher(SchoolMember):
    def __init__(self, name, age, sex, title, salary, prize):
        # 调用父类方法进行初始化
        super().__init__(name, age, sex)
        self.title = title
        self.salary = salary
        self.prize = prize

    def total_income(self):
        # 计算总收入
        return self.salary + self.prize

#打印信息
    def print_info(self):
        # 调用父类的print_info方法
        super().print_info()
        print(f"职称: {self.title}, 工资: {self.salary}, 奖金: {self.prize}, 总收入: {self.total_income()}")
        print()

#学生类
class Student(SchoolMember):
    def __init__(self, name, age, sex, dept, score):
        #调用父类方法进行初始化
        super().__init__(name, age, sex)
        self.dept = dept
        self.score = score

#打印信息
    def print_info(self):
        # 调用父类的print_info方法
        super().print_info()
        print(f"所属系部: {self.dept}, 成绩: {self.score}")
        print()


if __name__== "__main__":
    # 创建对象
    teacher = Teacher("江老师", 24, "女", "教授", 100000, 100000)
    student = Student("张三", 19, "男", "软件工程", 99)

    # 输出教师信息
    teacher.print_info()

    # 输出学生信息
    student.print_info()

    # 获取学校成员总人数
    print("析构之前")
    print(f"学校成员总人数: {SchoolMember.get_sum()}")
    print()

    # 当对象不再使用时，它们的析构函数将被调用，成员数自动减1
    del teacher
    del student

    # 再次获取学校成员总人数
    print("析构之后")
    print(f"学校成员总人数: {SchoolMember.get_sum()}()")

#6.汽车通常包括车型（model）、颜色（color）、品牌（make）、行驶里程（mileage）、出厂年份（year）等属性，
# 还可以包括的设置和获取行驶里程的方法。编写一个汽车类(Car)，包括上述行为（要求为实例对象行为）和方法，然后实现以下功能。
#（1）定义一个父类(Car)；
#（2）在父类的基础上，继承出加油车(GasCar)和新能源(ElecCar)车两个子类, 给ElecCa类再单独定义一个电池方法(Battery),
# 供ElecCar进行使用;对父类(Car)和继承类(ElecCar)进行重载,分别打印出是否需要油箱；
#（3）导入单个类Car，进行调用；
#（4）导入模块的多个类Car、ElecCar进行调用；
#（5）导入整个模块进行调用；
#（6）导入模块中的所有类进行调用。

#调用Carmo块
from Car import Car

#调用Car类
my_car = Car("比亚迪燃油车", "蓝色", "Tesla", 10000, 2024)
my_car.print_car_info()
print(my_car.need_gas_tank())

print("---------------------------------------")

from Car import GasCar, ElecCar

#调用GasCar类
my_gas_car = GasCar("长城燃油车", "红色", "Tesla", 10000, 2024)
my_gas_car.print_car_info()
print(my_gas_car.need_gas_tank())

#调用ElecCar类
my_elec_car = ElecCar("小米Su 7", "黑色", "Tesla", 20000, 2023, 100)
my_elec_car.print_car_info()
print(my_elec_car.need_gas_tank())
print(my_elec_car.Battery())

print("----------------------------------")
from Car import *

#调用Car类
my_car = Car("长安", "黄色", "Tesla", 5000, 2024)
my_car.print_car_info()
print(my_car.need_gas_tank())

#调用ElecCar类
my_elec_car = ElecCar("问界M 7", "黑色", "Tesla", 10000, 2024, 500)
my_elec_car.print_car_info()
print(my_elec_car.need_gas_tank())
print(my_elec_car.Battery())

#7. 定义一个表示时间的类Time，要求它提供下面操作：
#（1）Time(hours,minutes,seconds)创建一个时间对象
#2）t.hours()、t. minutes()和t. seconds()分别返回时间对象t的小时、分钟和秒钟值
#（3）使用运算符==和<判断两个时间对象的相等和小于关系
#（4）使用运算符+和-为Time对象定义加法和减法操作，例如t1+t1表示基于当前时间t1向后延长一段t2时间，而t1-t2则表示基于当前时间t1向前提前一段t2时间。
class Time:
    #构造
    def __init__(self, hours, minutes, seconds):
        self.hours = hours
        self.minutes = minutes
        self.seconds = seconds
        self.normalize()

    #检查
    def normalize(self):
        # 确保分钟和秒都在合理的范围内
        total_seconds = self.hours * 3600 + self.minutes * 60 + self.seconds
        self.hours = total_seconds // 3600
        self.minutes = (total_seconds % 3600) // 60
        self.seconds = total_seconds % 60

    #返回字符串
    def __repr__(self):
        return f"Time({self.hours}, {self.minutes}, {self.seconds})"

    #返回小时
    def Hours(self):
        return self.hours

    #返回分钟
    def Minutes(self):
        return self.minutes

    #返回秒
    def Seconds(self):
        return self.seconds

   #相等函数
    def __eq__(self, other):
        if not isinstance(other, Time):
            return False
        return (self.hours, self.minutes, self.seconds) == (other.hours, other.minutes, other.seconds)

   #大于小于
    def __lt__(self, other):
        if not isinstance(other, Time):
            return NotImplemented
        return (self.hours, self.minutes, self.seconds) < (other.hours, other.minutes, other.seconds)

    #相加
    def __add__(self, other):
        if not isinstance(other, Time):
            raise TypeError("Unsupported operation between instances of 'Time' and '{}'".format(type(other).__name__))
        total_seconds = (self.hours * 3600 + self.minutes * 60 + self.seconds) + (
                    other.hours * 3600 + other.minutes * 60 + other.seconds)
        return Time(total_seconds // 3600, (total_seconds % 3600) // 60, total_seconds % 60)

    #相减
    def __sub__(self, other):
        if not isinstance(other, Time):
            raise TypeError("Unsupported operation between instances of 'Time' and '{}'".format(type(other).__name__))
        total_seconds = (self.hours * 3600 + self.minutes * 60 + self.seconds) - (
                    other.hours * 3600 + other.minutes * 60 + other.seconds)
        if total_seconds < 0:
            raise ValueError("Resulting time would be negative")
        return Time(total_seconds // 3600, (total_seconds % 3600) // 60, total_seconds % 60)

    # 示例
if __name__ =="__main__":
    #创建对象
    t1 = Time(10, 30, 15)
    t2 = Time(2, 15, 0)

    #打印时间
    print(f"{t1.Hours()}小时, {t1.Minutes()}分钟, {t1.Seconds()}秒")
    print(f"{t2.Hours()}小时, {t2.Minutes()}分钟, {t2.Seconds()}秒")
    print()

    #判断相等
    print(t1 == t2)
    print()

    #判断小于
    print(t1 < t2)
    print()

    #相加
    t3 = t1 + t2
    print(t3)
    print()

    #相减可能非法
    try:
        t4 = t1 - t2
    except ValueError as e:
        print(e)

# #8.编写图书管理模块,实现以下功能:
# #(1)Book类和BookManagementSystem类;
# #(2)Book类表示单本图书,包含书名和ISBN两个属性,__str__返回图书的内容；
# #（3）BookManagementSystem类负责管理图书数据，包含系列的方法，包括加载和保存图书信息、
# # 添加新图书、删除图书、修改图书、查找图书和显示所有图书等功能。
#
import json


class Book:
    #构造
    def __init__(self, title, isbn):
        self.title = title
        self.isbn = isbn
    #返回字符串
    def __str__(self):
        return f"Book(title={self.title}, isbn={self.isbn})"


class BookManagementSystem:
    # 构造
    def __init__(self, filename="books.json"):
        self.filename = filename
        self.books = self.load_books()

    #打开文件，加载
    def load_books(self):
        try:
            with open(self.filename, "r") as file:
                books_data = json.load(file)
                return [Book(data["title"], data["isbn"]) for data in books_data]
        except FileNotFoundError:
            return []

    def save_books(self):
        with open(self.filename, "w") as file:
            books_data = [{"title": book.title, "isbn": book.isbn} for book in self.books]
            json.dump(books_data, file, indent=4)

   #添加
    def add_book(self, book):
        self.books.append(book)
        self.save_books()

   #删除
    def delete_book(self, isbn):
        for book in self.books:
            if book.isbn == isbn:
                self.books.remove(book)
                self.save_books()
                return True
        return False


    def update_book(self, isbn, new_title=None, new_isbn=None):
        for book in self.books:
            if book.isbn == isbn:
                if new_title:
                    book.title = new_title
                if new_isbn:
                    book.isbn = new_isbn
                self.save_books()
                return True
        return False

    #查找
    def find_book(self, isbn):
        for book in self.books:
            if book.isbn == isbn:
                return book
        return None

    #展示
    def show_all_books(self):
        for book in self.books:
            print(book)




if __name__ == "__main__":
    # 初始化图书管理系统
    bms = BookManagementSystem()

    # 添加图书
    bms.add_book(Book("Python", "1111491946237"))
    bms.add_book(Book("C++", "2220132350884"))

    # 显示所有图书
    bms.show_all_books()
    print()

    # 修改图书信息
    bms.update_book("2220132350884", new_title="New_C++")
    print()

    # 查找图书
    book = bms.find_book("1111491946237")
    if book:
        print("找到该书:", book)
    else:
        print("未找到")
    print()

    # 删除图书
    bms.delete_book("1111491946237")

    # 再次显示所有图书，以确认删除
    bms.show_all_books()

#9.设计一个枪战小游戏:CS对战
class Gun:

    #初始化枪对象
    def __init__(self):
        #param model: 枪的型号
        self.model = input("请输入抢的型号:")

        #param damage: 枪的杀伤力
        self.damage =input("请输入抢的伤害:")

        #子弹数量
        self.bullet_count = 0

    # 增加子弹数量
    def add_bullets(self,count):
        #增加子弹数量
        self.bullet_count += count
        print(f"给 {self.model} 添加了 {count} 颗子弹，当前子弹数：{self.bullet_count}")

    # 向敌人射击
    def shoot(self, enemy):
        #向敌人射击
        if self.bullet_count <= 0:
            print("枪里没有子弹了！")
            return
        self.bullet_count -= 1
        print("射中敌人！")


class Player:
   #初始化玩家对象
    def __init__(self):

        #玩家姓名
        self.name =input("请输入玩家职称：")

        #玩家血量
        self.hp = int(input("请输入玩家血量（正整数）："))

        #玩家的抢
        self.gun = None

    #玩家受到伤害
    def hurt(self, damage):

        self.hp -= damage
        if self.hp <= 0:
            print(f"{self.name} 挂了！")
            return True
        else:
            print(f"{self.name} 受伤了，当前血量：{self.hp}")
            return False

    def check(self):
        if self.gun.bullet_count <= 0:
            print("弹药不足")
            # 自动装填10发子弹
            self.gun.add_bullets(10)
            print("武器已装填子弹！")
            return
        else:
            print("当前子弹数：{self.bullet_count}")
    #玩家向敌人开火

    #增加子弹
    def add_bullets(self):
        count = int(input("请输入增加的子弹数量："))
        # 增加子弹数量
        self.gun.bullet_count += count
        print(f"给 {self.gun.model} 添加了 {count} 颗子弹，当前子弹数：{self.gun.bullet_count}")

    def fire(self, enemy):
        if self.gun is None:
            print("没有武器，无法开火！")
            return
        if self.gun.bullet_count <= 0:
            print("没有子弹，无法开火！")
            return
        self.gun.shoot(enemy)
        enemy.hurt(25)

def menu():
    print("游戏功能：")
    print("1.创建警察角色")
    print("2.创建土匪角色")
    print("3.给警察装备枪")
    print("4.检查子弹数量")
    print("5.增加子弹数量")
    print("6.警察使用枪向敌人开火")



if __name__ =="__main__":

    menu()
    print()
    # 警察变量
    policeman = None
    # 土匪变量
    badman = None
    # 枪变量
    gun = None

    while True:
        n = int(input("请输入您选择的功能："))
        # 创建警察对象
        if n == 1:
            policeman = Player()
            print()

        # 创建土匪对象
        if n == 2:
            badman = Player()
            print()

        # 给警察装备枪
        if n == 3:
            policeman.gun = Gun()
            print()

        # 检查子弹数量
        if n == 4:
            policeman.check()
            print()

        #增加子弹
        if n == 5:
            policeman.add_bullets()

        # 向敌人开火
        if n == 6:
            policeman.fire(badman)
            if badman.hp == 0:
                print('游戏结束')
                break
            print()



